The present invention relates to methods for developing new computer systems and, more particularly, to methods for speeding the development of such systems through the use of better software development and testing procedures.
A large amount of development effort and monetary investment is required to design a new computer hardware architecture, develop a commercial computer product implementing the new architecture, and develop system and user software for use on the new computer product. As the time to develop new computer hardware and software increases, both the product investment cost and the product marketability may be adversely affected. Thus, greater commercial product development time usually requires more monetary investment by the manufacturer and its suppliers and users and, further, runs greater risk that anticipated market needs and other market conditions will have eroded before the new product is commercially available. Accordingly, it is desirable and beneficial to suppliers, manufacturers and users for economic and other reasons that the total hardware/software development time cycle be shortened.
More particularly, the development of new computer systems has been a slow and lengthy process because of the many layers of components involved. For example, the operating system cannot be completed until the hardware is available; compilers and run-time libraries cannot be completed until the operating system is available; applications cannot be completed until the compilers and run-time libraries are available. In practice, each "layer" itself contains components having interdependencies among themselves and with components in other layers.
If development and testing of each component waits until all of the other components upon which it depends are completed, the total development time for the whole system can easily become intolerably long. Various techniques have accordingly been devised to speed the development process, but the results have been very limited.
One common technique for speeding system development employs cross-tools on an existing computer system. Such tools include cross-compilers and cross-linkers.
A cross-compiler executes on one kind of computer system and generates code for another kind of computer system. Ideally, the object file output of the cross-compiler is in the form that ultimately will be produced by a corresponding compiler on the new computer system. A cross-assembler is a particular kind of cross-compiler for a language that is closely related to another kind of computer system.
Similarly, a cross-linker combines object files from one or more cross-compilers and transforms them into a form required for loading and execution on another kind of system.
Cross-compiling and cross-linking have value since they permit the source code for programs intended for execution on the new computer system to be prepared, compiled and linked. The compilation and linking steps can detect many kinds of errors that can be corrected without recourse to the new system hardware and other components therefor.
However, many other kinds of errors cannot be detected by cross-compiling and cross-linking procedures. A more complete check of new software requires execution of that software.
Simulation of new hardware is a common technique for checking the design of new computer system hardware as well as for checking programs that will ultimately execute on that hardware. A "whole machine" simulator is usually employed for software development and checkout. In a whole machine simulator, the behavior of a complete machine is emulated including all or nearly all of its instructions, some amount of memory, and a small number of input/output devices.
Whole machine simulators are useful for early development and checkout of an operating system. In this application of the simulator, the operating system typically depends on precise details of the behavior of the new system hardware. Further, the relevant parts of the operating system are relatively limited and self-contained.
While simulation procedures provide some satisfaction for operating system development checkout, they are far less satisfactory for higher software levels. Thus, user programs or other software above the operating system level depend on a greater variety of run-time components and capabilities. As a result, higher level components may not be testable until lower level components are available.
If lower level components are available, the execution time needed to simulate the code therefor can easily exceed the execution time needed to simulate the particular code that a programmer wants to test. Further, such lower level components themselves are new and usually not thoroughly exercised. For this reason, many apparent problems in a component under test will turn out to be due to a problem in some other component. Conversely, distrust of other components will often draw attention away from the immediate component where some problems will actually occur.
In some cases, it is possible to reduce these problems by extending the simulator to include built-in emulation of certain lower level components, perhaps even the majority of the frequently used parts of an entire operating system. Some improvement may be achieved in this manner, but it involves another heavy development expenditure for a new subsystem that will have yet another set of limitations and problems.
It is accordingly desirable that a new and basically different process be conceived and actualized to provide significantly faster, more efficient and more economic development of new computer systems including software components therefor. The present invention is directed to this end.